// Video.js - 视频模型
const { sequelize } = require('../config/db');
const redisUtil = require('../utils/redisUtil');
const { getCache, setCache, deleteCache, deleteCachePattern } = redisUtil;

class Video {
  constructor() {
    // 视频模型不需要定义完整结构，因为我们主要使用videos_detail视图
  }

  /**
   * 获取推荐视频列表（按collect_count降序，使用Redis zset缓存）
   * @param {number} page - 页码，默认1
   * @param {number} pageSize - 每页数量，默认10
   * @param {boolean} skipInitZset - 是否跳过初始化zset缓存（避免循环调用）
   * @returns {Promise<Array>} - 视频列表
   */
  static async getRecommendedVideos(page = 1, pageSize = 10, skipInitZset = false) {
    try {
      // 尝试从Redis zset获取数据
      const client = redisUtil.getClient();
      if (client) {
        try {
          const zsetKey = 'videos:recommended:zset';
          const offset = (page - 1) * pageSize;
          const end = offset + pageSize - 1;
          
          // 从zset获取指定范围的数据（降序，收藏数高的在前），适配ioredis API
          const cachedVideos = await client.zrevrange(zsetKey, offset, end, 'WITHSCORES');
          
          if (cachedVideos && cachedVideos.length > 0) {
            // 解析zset中的数据 - ioredis返回的是值和分数交替的数组
            const videos = [];
            for (let i = 0; i < cachedVideos.length; i += 2) {
              videos.push(JSON.parse(cachedVideos[i]));
            }
            console.log(`从Redis zset获取推荐视频，第${page}页，共${videos.length}个视频`);
            return videos;
          }
        } catch (zsetError) {
          console.warn('Redis zset读取失败，回退到数据库查询:', zsetError.message);
          // 如果zset读取失败，继续从数据库查询
        }
      }
      
      // 从数据库查询
      const offset = (page - 1) * pageSize;
      const query = `
        SELECT * FROM videos_detail 
        WHERE status = 1 
        ORDER BY collect_count DESC 
        LIMIT :pageSize OFFSET :offset
      `;
      
      // 直接使用sequelize.query返回的结果
      const results = await sequelize.query(query, {
        replacements: { pageSize, offset },
        type: sequelize.QueryTypes.SELECT
      });
      
      // 如果是第一页且Redis可用且未设置跳过初始化，才初始化zset缓存
      // 这避免了从initRecommendedVideosZset调用时的循环依赖
      if (page === 1 && redisUtil.getClient() && !skipInitZset) {
        try {
          // 传递this作为Video模型参数，避免循环依赖
          await redisUtil.initRecommendedVideosZset(this);
          console.log('推荐视频zset缓存已初始化');
        } catch (initError) {
          console.warn('初始化推荐视频zset失败:', initError.message);
        }
      }
      
      // 确保返回的是数组
      return Array.isArray(results) ? results : [];
    } catch (error) {
      console.error('获取推荐视频失败:', error);
      return [];
    }
  }

  /**
   * 获取热门视频列表（按view_count降序，使用Redis zset缓存）
   * @param {number} page - 页码，默认1
   * @param {number} pageSize - 每页数量，默认10
   * @param {boolean} skipInitZset - 是否跳过初始化zset缓存（避免循环调用）
   * @returns {Promise<Array>} - 视频列表
   */
  static async getHotVideos(page = 1, pageSize = 10, skipInitZset = false) {
    try {
      // 尝试从Redis zset获取数据
      const client = redisUtil.getClient();
      if (client) {
        try {
          const zsetKey = 'videos:hot:zset';
          const offset = (page - 1) * pageSize;
          const end = offset + pageSize - 1;
          
          // 从zset获取指定范围的数据（降序，浏览量高的在前），适配ioredis API
          const cachedVideos = await client.zrevrange(zsetKey, offset, end, 'WITHSCORES');
          
          if (cachedVideos && cachedVideos.length > 0) {
            // 解析zset中的数据 - ioredis返回的是值和分数交替的数组
            const videos = [];
            for (let i = 0; i < cachedVideos.length; i += 2) {
              videos.push(JSON.parse(cachedVideos[i]));
            }
            console.log(`从Redis zset获取热门视频，第${page}页，共${videos.length}个视频`);
            return videos;
          }
        } catch (zsetError) {
          console.warn('Redis zset读取失败，回退到数据库查询:', zsetError.message);
          // 如果zset读取失败，继续从数据库查询
        }
      }
      
      // 从数据库查询
      const offset = (page - 1) * pageSize;
      const query = `
        SELECT * FROM videos_detail 
        WHERE status = 1 
        ORDER BY view_count DESC 
        LIMIT :pageSize OFFSET :offset
      `;
      
      // 直接使用sequelize.query返回的结果
      const results = await sequelize.query(query, {
        replacements: { pageSize, offset },
        type: sequelize.QueryTypes.SELECT
      });
      
      // 如果是第一页且Redis可用且未设置跳过初始化，才初始化zset缓存
      // 这避免了从initHotVideosZset调用时的循环依赖
      if (page === 1 && redisUtil.getClient() && !skipInitZset) {
        try {
          // 传递this作为Video模型参数，避免循环依赖
          await redisUtil.initHotVideosZset(this);
          console.log('热门视频zset缓存已初始化');
        } catch (initError) {
          console.warn('初始化热门视频zset失败:', initError.message);
        }
      }
      
      // 确保返回的是数组
      return Array.isArray(results) ? results : [];
    } catch (error) {
      console.error('获取热门视频失败:', error);
      return [];
    }
  }

  /**
   * 获取幻灯片视频列表（按like_count降序，最多6个，使用Redis缓存）
   * @returns {Promise<Array>} - 视频列表
   */
  static async getSlideVideos() {
    const cacheKey = 'videos:slide';
    const cacheExpire = 3600; // 1小时
    
    try {
      // 尝试从缓存获取
      const cachedData = await getCache(cacheKey);
      if (cachedData) {
        console.log('从缓存获取轮播视频');
        return cachedData;
      }
      
      // 从数据库查询
      const query = `
        SELECT * FROM videos_detail 
        WHERE status = 1 
        ORDER BY like_count DESC 
        LIMIT 6
      `;
      
      // 直接使用sequelize.query返回的结果
      const results = await sequelize.query(query, {
        type: sequelize.QueryTypes.SELECT
      });
      
      // 设置缓存
      await setCache(cacheKey, Array.isArray(results) ? results : [], cacheExpire);
      console.log('轮播视频已缓存');
      
      // 确保返回的是数组
      return Array.isArray(results) ? results : [];
    } catch (error) {
      console.error('获取幻灯片视频失败:', error);
      // 缓存失败不影响返回数据，继续返回数据库结果
      try {
        const query = `
          SELECT * FROM videos_detail 
          WHERE status = 1 
          ORDER BY like_count DESC 
          LIMIT 6
        `;
        const results = await sequelize.query(query, {
          type: sequelize.QueryTypes.SELECT
        });
        return Array.isArray(results) ? results : [];
      } catch (dbError) {
        return [];
      }
    }
  }

  /**
   * 根据类别获取视频列表（使用Redis缓存）
   * @param {number} categoryId - 类别ID
   * @param {number} page - 页码，默认1
   * @param {number} pageSize - 每页数量，默认10
   * @returns {Promise<Array>} - 视频列表
   */
  /**
   * 获取最新视频列表（按id降序，使用Redis缓存，缓存时间较短）
   * @param {number} page - 页码，默认1
   * @param {number} pageSize - 每页数量，默认10
   * @returns {Promise<Array>} - 视频列表
   */
  static async getLatestVideos(page = 1, pageSize = 10) {
    // 最新视频使用较短的缓存时间（1分钟），因为数据变化频繁
    const cacheKey = `videos:latest:page:${page}:size:${pageSize}`;
    const cacheExpire = 60; // 1分钟
    
    try {
      // 尝试从缓存获取
      const cachedData = await getCache(cacheKey);
      if (cachedData) {
        console.log(`从缓存获取最新视频，第${page}页`);
        return cachedData;
      }
      
      // 从数据库查询（按id降序，最新的视频在前）
      const offset = (page - 1) * pageSize;
      const query = `
        SELECT * FROM videos_detail 
        WHERE status = 1 
        ORDER BY id DESC 
        LIMIT :pageSize OFFSET :offset
      `;
      
      // 直接使用sequelize.query
      const results = await sequelize.query(query, {
        replacements: { pageSize, offset },
        type: sequelize.QueryTypes.SELECT
      });
      
      const videos = Array.isArray(results) ? results : [];
      
      // 设置缓存，使用较短的过期时间
      await setCache(cacheKey, videos, cacheExpire);
      console.log(`最新视频已缓存，第${page}页，缓存时间1分钟`);
      
      return videos;
    } catch (error) {
      console.error('获取最新视频失败:', error);
      // 缓存失败不影响返回数据，继续返回数据库结果
      try {
        const offset = (page - 1) * pageSize;
        const query = `
          SELECT * FROM videos_detail 
          WHERE status = 1 
          ORDER BY id DESC 
          LIMIT :pageSize OFFSET :offset
        `;
        const results = await sequelize.query(query, {
          replacements: { pageSize, offset },
          type: sequelize.QueryTypes.SELECT
        });
        return Array.isArray(results) ? results : [];
      } catch (dbError) {
        return [];
      }
    }
  }

  /**
   * 根据类别获取视频列表（使用Redis缓存）
   * @param {number} categoryId - 类别ID
   * @param {number} page - 页码，默认1
   * @param {number} pageSize - 每页数量，默认10
   * @returns {Promise<Array>} - 视频列表
   */
  static async getVideosByCategory(categoryId, page = 1, pageSize = 10) {
    const cacheKey = `videos:category:${categoryId}:page:${page}:size:${pageSize}`;
    const cacheExpire = 1800; // 30分钟
    
    try {
      // 尝试从缓存获取
      const cachedData = await getCache(cacheKey);
      if (cachedData) {
        console.log(`从缓存获取分类${categoryId}的视频，第${page}页`);
        return cachedData;
      }
      
      // 从数据库查询
      const offset = (page - 1) * pageSize;
      const query = `
        SELECT * FROM videos_detail 
        WHERE status = 1 AND category_id = :categoryId 
        ORDER BY created_at DESC 
        LIMIT :pageSize OFFSET :offset
      `;
      
      // 直接使用sequelize.query返回的结果
      const results = await sequelize.query(query, {
        replacements: { categoryId, pageSize, offset },
        type: sequelize.QueryTypes.SELECT
      });
      
      const videos = Array.isArray(results) ? results : [];
      
      // 设置缓存
      await setCache(cacheKey, videos, cacheExpire);
      console.log(`分类${categoryId}的视频已缓存，第${page}页`);
      
      return videos;
    } catch (error) {
      console.error('获取类别视频失败:', error);
      // 缓存失败不影响返回数据，继续返回数据库结果
      try {
        const offset = (page - 1) * pageSize;
        const query = `
          SELECT * FROM videos_detail 
          WHERE status = 1 AND category_id = :categoryId 
          ORDER BY created_at DESC 
          LIMIT :pageSize OFFSET :offset
        `;
        const results = await sequelize.query(query, {
          replacements: { categoryId, pageSize, offset },
          type: sequelize.QueryTypes.SELECT
        });
        return Array.isArray(results) ? results : [];
      } catch (dbError) {
        return [];
      }
    }
  }

  /**
   * 获取视频总数（用于分页）
   * @param {Object} conditions - 查询条件
   * @returns {Promise<number>} - 视频总数
   */
  static async getTotalVideos(conditions = {}) {
    let query = 'SELECT COUNT(*) as total FROM videos_detail WHERE status = 1';
    const replacements = {};
    
    if (conditions.categoryId) {
      query += ' AND category_id = :categoryId';
      replacements.categoryId = conditions.categoryId;
    }
    
    try {
      // 直接使用sequelize.query返回的对象，而不是解构
      const results = await sequelize.query(query, {
        replacements,
        type: sequelize.QueryTypes.SELECT
      });
      
      // 完全安全地处理结果
      if (!Array.isArray(results) || results.length === 0 || !results[0] || typeof results[0].total === 'undefined') {
        return 0;
      }
      
      return Number(results[0].total) || 0;
    } catch (error) {
      console.error('获取视频总数失败:', error);
      return 0;
    }
  }

  /**
   * 根据ID获取视频详情（使用Redis缓存）
   * @param {number} id - 视频ID
   * @returns {Promise<Object|null>} - 视频详情对象或null
   */
  static async getVideoById(id) {
    const cacheKey = `video:detail:${id}`;
    const cacheExpire = 1800; // 30分钟
    
    console.log(`[缓存调试] 尝试获取视频详情，ID: ${id}，缓存键: ${cacheKey}`);
    
    try {
      // 尝试从缓存获取
      console.log(`[缓存调试] 调用getCache，键: ${cacheKey}`);
      const cachedData = await getCache(cacheKey);
      
      console.log(`[缓存调试] getCache返回结果: ${cachedData ? '缓存命中' : '缓存未命中'}`);
      
      if (cachedData) {
        console.log(`从缓存获取视频详情，ID: ${id}`);
        return cachedData;
      }
      
      // 从数据库查询
      const query = `
        SELECT * FROM videos_detail 
        WHERE id = :id AND status = 1
      `;
      
      console.log(`[缓存调试] 执行数据库查询，ID: ${id}`);
      // 直接使用sequelize.query返回的结果
      const results = await sequelize.query(query, {
        replacements: { id },
        type: sequelize.QueryTypes.SELECT
      });
      
      // 确保返回的是单个对象或null
      const video = Array.isArray(results) && results.length > 0 ? results[0] : null;
      
      // 设置缓存（只缓存存在的视频）
      if (video) {
        // 从Redis获取最新的浏览量计数器值
        const client = redisUtil.getClient();
        const counterKey = `video:view:${id}`;
        
        if (client) {
          try {
            // 获取Redis中的浏览量计数器值
            const viewCountInRedis = await client.get(counterKey);
            
            if (viewCountInRedis && !isNaN(parseInt(viewCountInRedis))) {
              // 如果Redis中有计数器值，使用它来更新视频详情
              console.log(`[缓存调试] getVideoById - 同步Redis计数器到视频详情，ID: ${id}，Redis值: ${viewCountInRedis}`);
              video.view_count = parseInt(viewCountInRedis);
            }
          } catch (redisError) {
            console.warn(`[缓存调试] 获取浏览量计数器失败:`, redisError.message);
            // 出错时不影响主流程，继续使用数据库中的值
          }
        }
        
        console.log(`[缓存调试] 调用setCache，键: ${cacheKey}，过期时间: ${cacheExpire}秒`);
        const setResult = await setCache(cacheKey, video, cacheExpire);
        console.log(`[缓存调试] setCache执行结果: ${setResult ? '成功' : '失败'}`);
        console.log(`视频详情已缓存，ID: ${id}`);
      }
      
      return video;
    } catch (error) {
      console.error('获取视频详情失败:', error);
      // 缓存失败不影响返回数据，继续返回数据库结果
      try {
        const query = `
          SELECT * FROM videos_detail 
          WHERE id = :id AND status = 1
        `;
        const results = await sequelize.query(query, {
          replacements: { id },
          type: sequelize.QueryTypes.SELECT
        });
        return Array.isArray(results) && results.length > 0 ? results[0] : null;
      } catch (dbError) {
        return null;
      }
    }
  }

  /**
   * 更新视频观看次数
   * @param {number} id - 视频ID
   * @returns {Promise<boolean>} - 更新是否成功
   */
  static async updateViewCount(id) {
    try {
      console.log(`[缓存调试] updateViewCount - 开始更新观看次数，ID: ${id}`);
      
      // 1. 增加Redis中的计数器
      const counterKey = `video:view:${id}`;
      await redisUtil.incrementCounter(counterKey);
      // 设置过期时间为24小时，确保即使服务器重启也不会丢失太多数据
      await redisUtil.expire(counterKey, 86400);
      
      // 2. 将视频ID加入待更新队列，等待定时批量处理
      redisUtil.queueViewCountUpdate(id);
      
      // 3. 更新zset缓存中的单个视频数据
      const client = redisUtil.getClient();
      if (client) {
        console.log(`[缓存调试] updateViewCount - 检查是否需要更新zset，ID: ${id}`);
        const hotZsetKey = 'videos:hot:zset';
        const maxVideosInZset = 100;
        
        // 获取zset的元素数量
        const zsetCount = await client.zcard(hotZsetKey);
        
        // 直接从数据库查询视频详情，避免循环调用getVideoById
        const query = `
          SELECT * FROM videos_detail 
          WHERE id = :id AND status = 1
        `;
        const results = await sequelize.query(query, {
          replacements: { id },
          type: sequelize.QueryTypes.SELECT
        });
        
        const videoDetail = Array.isArray(results) && results.length > 0 ? results[0] : null;
        if (videoDetail) {
          const currentScore = videoDetail.view_count + 1; // 当前视频的观看量(+1)
          
          try {
            if (zsetCount < maxVideosInZset) {
              // zset未满，直接添加或更新
              console.log(`[缓存调试] updateViewCount - zset未满(${zsetCount}/${maxVideosInZset})，直接添加视频`);
              await client.zadd(hotZsetKey, { 
                score: currentScore, 
                value: JSON.stringify(videoDetail)
              });
              console.log(`视频${id}已添加到热门视频zset`);
            } else {
              // zset已满，比较当前视频与zset中最小值的大小
              console.log(`[缓存调试] updateViewCount - zset已满(${zsetCount}/${maxVideosInZset})，检查是否需要替换`);
              
              // 获取zset中最小分数的元素
              const minScoreElement = await client.zrange(hotZsetKey, 0, 0, 'WITHSCORES');
              
              if (minScoreElement && minScoreElement.length > 0) {
                // ioredis返回的是数组，格式为[value1, score1, value2, score2, ...]
                const minScore = parseFloat(minScoreElement[1]);
                
                console.log(`[缓存调试] updateViewCount - zset最小分数: ${minScore}，当前视频分数: ${currentScore}`);
                
                if (currentScore > minScore) {
                  // 当前视频分数大于zset中的最小分数，替换它
                  console.log(`[缓存调试] updateViewCount - 当前视频分数更高，替换最小值`);
                  
                  // 添加当前视频到zset
                  await client.zadd(hotZsetKey, { 
                    score: currentScore, 
                    value: JSON.stringify(videoDetail)
                  });
                  
                  // 删除最小分数的元素，确保zset大小不超过最大值
                  await client.zpopmin(hotZsetKey);
                  console.log(`视频${id}已添加到热门视频zset，并移除了一个最低分视频`);
                } else {
                  console.log(`[缓存调试] updateViewCount - 当前视频分数不大于最小值，不更新zset`);
                }
              }
            }
          } catch (zsetError) {
            console.warn(`更新热门zset缓存失败:`, zsetError.message);
            // 如果zset更新失败，回退到清除缓存模式
            await deleteCachePattern('videos:hot:*');
          }
        }
      }
      
      // 4. 只增加计数器，不立即清除缓存
      // 缓存会在定时更新数据库后统一刷新，这样可以避免频繁的数据库查询
      console.log(`[缓存调试] updateViewCount - 已增加Redis计数器并加入更新队列，ID: ${id}`);
      
      return true; // 返回成功
    } catch (error) {
      console.error('更新视频观看次数失败:', error);
      
      // 即使缓存更新失败，也要确保数据库更新
      try {
        // 确保视频ID已加入待更新队列
        redisUtil.queueViewCountUpdate(id);
        
        // 直接更新数据库作为兜底
        const query = `UPDATE videos SET view_count = view_count + 1 WHERE id = :id`;
        const [affectedRows] = await sequelize.query(query, {
          replacements: { id },
          type: sequelize.QueryTypes.UPDATE
        });
        
        // 错误处理中也不立即清除缓存，保持逻辑一致性
        console.log(`[缓存调试] updateViewCount - 错误处理中，已确保ID: ${id}加入更新队列`);
        
        return affectedRows > 0;
      } catch (dbError) {
        console.error(`数据库更新也失败，ID: ${id}`, dbError);
        return false;
      }
    }
  }

  /**
   * 更新视频点赞数
   * @param {number} id - 视频ID
   * @param {number} count - 要增加或减少的数量（正数增加，负数减少）
   * @returns {Promise<boolean>} - 更新是否成功
   */
  static async updateLikeCount(id, count) {
    try {
      // 先检查视频是否存在
      const checkQuery = `SELECT id FROM videos WHERE id = :id`;
      const result = await sequelize.query(checkQuery, {
        replacements: { id },
        type: sequelize.QueryTypes.SELECT
      });
      
      if (result.length === 0) {
        console.log(`视频ID ${id} 不存在`);
        return false;
      }
      
      // 更新点赞数，确保不会小于0
      const updateQuery = `UPDATE videos SET like_count = GREATEST(0, like_count + :count) WHERE id = :id`;
      const [affectedRows] = await sequelize.query(updateQuery, {
        replacements: { id, count },
        type: sequelize.QueryTypes.UPDATE
      });
      
      if (affectedRows > 0) {
        // 清除相关缓存
        await deleteCache(`video:detail:${id}`);
        await deleteCache('videos:slide');
        await deleteCachePattern('videos:category:*');
        
        // 尝试更新推荐zset中的单个视频数据
        const client = redisUtil.getClient();
        if (client) {
          const videoDetail = await this.getVideoById(id);
          if (videoDetail) {
            try {
              const recommendedZsetKey = 'videos:recommended:zset';
              const maxVideosInZset = 100;
              
              // 获取zset的元素数量
              const zsetCount = await client.zcard(recommendedZsetKey);
              
              if (zsetCount < maxVideosInZset) {
                // zset未满，直接添加或更新
                await client.zadd(recommendedZsetKey, { 
                    score: videoDetail.collect_count, 
                    value: JSON.stringify(videoDetail)
                  });
              } else {
                // zset已满，获取最小score
                const minScoreResult = await client.zrangebyscore(recommendedZsetKey, 0, 0);
                if (minScoreResult && minScoreResult.length > 0) {
                  const minScore = minScoreResult[0].score;
                  const currentScore = videoDetail.collect_count;
                  
                  if (currentScore > minScore) {
                    // 当前视频score大于最小score，添加到zset
                    await client.zadd(recommendedZsetKey, { 
                      score: currentScore, 
                      value: JSON.stringify(videoDetail)
                    });
                    
                    // 如果zset超过最大容量，删除最小分数的元素
                    if (zsetCount >= maxVideosInZset) {
                      await client.zPopMin(recommendedZsetKey, { count: 1 });
                      console.log(`推荐视频zset超过最大容量，已移除最低分视频`);
                    }
                  } else {
                    console.log(`视频${id}的收藏数(${currentScore})不大于zset中最小分数，不更新推荐zset`);
                  }
                }
              }
            } catch (zsetError) {
              console.warn(`更新推荐zset缓存失败:`, zsetError.message);
              // 如果zset更新失败，回退到清除缓存模式
              await deleteCachePattern('videos:recommended:*');
            }
          }
        }
      }
      
      console.log(`点赞数更新完成，影响行数: ${affectedRows}`);
      return affectedRows > 0;
    } catch (error) {
      console.error(`更新点赞数失败，ID: ${id}`, error);
      return false;
    }
  }

  /**
   * 更新视频收藏数
   * @param {number} id - 视频ID
   * @param {number} count - 要增加或减少的数量（正数增加，负数减少）
   * @returns {Promise<boolean>} - 更新是否成功
   */
  static async updateCollectCount(id, count) {
    try {
      // 先检查视频是否存在
      const checkQuery = `SELECT id FROM videos WHERE id = :id`;
      const result = await sequelize.query(checkQuery, {
        replacements: { id },
        type: sequelize.QueryTypes.SELECT
      });
      
      if (result.length === 0) {
        console.log(`视频ID ${id} 不存在`);
        return false;
      }
      
      // 更新收藏数，确保不会小于0
      const updateQuery = `UPDATE videos SET collect_count = GREATEST(0, collect_count + :count) WHERE id = :id`;
      const [affectedRows] = await sequelize.query(updateQuery, {
        replacements: { id, count },
        type: sequelize.QueryTypes.UPDATE
      });
      
      if (affectedRows > 0) {
        // 清除相关缓存
        await deleteCache(`video:detail:${id}`);
        await deleteCachePattern('videos:category:*');
        
        // 尝试更新推荐zset中的单个视频数据
        const client = redisUtil.getClient();
        if (client) {
          const videoDetail = await this.getVideoById(id);
          if (videoDetail) {
            try {
              const recommendedZsetKey = 'videos:recommended:zset';
              const maxVideosInZset = 100;
              
              // 获取zset的元素数量
              const zsetCount = await client.zcard(recommendedZsetKey);
              const currentScore = videoDetail.collect_count + count;
              
              if (zsetCount < maxVideosInZset) {
                // zset未满，直接添加或更新
                await client.zadd(recommendedZsetKey, { 
                  score: currentScore, 
                  value: JSON.stringify(videoDetail)
                });
                console.log(`视频${id}已添加到推荐视频zset`);
              } else {
                // zset已满，获取最小score
                const minScoreResult = await client.zrangebyscore(recommendedZsetKey, 0, 0);
                if (minScoreResult && minScoreResult.length > 0) {
                  const minScore = minScoreResult[0].score;
                  
                  if (currentScore > minScore) {
                    // 当前视频score大于最小score，添加到zset
                    await client.zadd(recommendedZsetKey, { 
                      score: currentScore, 
                      value: JSON.stringify(videoDetail)
                    });
                    
                    // 如果zset超过最大容量，删除最小分数的元素
                    if (zsetCount >= maxVideosInZset) {
                      await client.zPopMin(recommendedZsetKey, { count: 1 });
                      console.log(`推荐视频zset超过最大容量，已移除最低分视频`);
                    }
                  } else {
                    console.log(`视频${id}的收藏数(${currentScore})不大于zset中最小分数，不更新推荐zset`);
                  }
                }
              }
            } catch (zsetError) {
              console.warn(`更新推荐zset缓存失败:`, zsetError.message);
              // 如果zset更新失败，回退到清除缓存模式
              await deleteCachePattern('videos:recommended:*');
            }
          }
        }
        console.log(`收藏数更新完成，影响行数: ${affectedRows}`);
      }
      
      return affectedRows > 0;
    } catch (error) {
      console.error(`更新收藏数失败，ID: ${id}`, error);
      return false;
    }
  }
}

module.exports = Video;